Towards a Tool-based Development Methodology for Pervasive Computing Applications

Despite much progress, developing a pervasive computing application remains a challenge because of a lack of conceptual frameworks and supporting tools. This challenge involves coping with heterogeneous devices, overcoming the intricacies of distributed systems technologies, working out an architecture for the application, encoding it in a program, writing specific code to test the application, and finally deploying it. This paper presents a design language and a tool suite covering the development life-cycle of a pervasive computing application. The design language allows to define a taxonomy of area-specific building-blocks, abstracting over their heterogeneity. This language also includes a layer to define the architecture of an application, following an architectural pattern commonly used in the pervasive computing domain. Our underlying methodology assigns roles to the stakeholders, providing separation of concerns. Our tool suite includes a compiler that takes design artifacts written in our language as input and generates a programming framework that supports the subsequent development stages, namely implementation, testing, and deployment. Our methodology has been applied on a wide spectrum of areas. Based on these experiments, we assess our approach through three criteria: expressiveness, usability, and productivity

Optimisation du filtrage par transformations de programmes

Stage de DEADurant ce stage, nous nous sommes inspirés des techniques d'optimisations par transformations de programmes et nous avons proposé une solution adaptée aux programmes de filtrage du logiciel Tom, développé dans l'équipe Protheo. Après avoir présenté ces techniques ainsi que le logiciel Tom, nous définirons un système de transformations applicable aux programmes de filtrage syntaxique et nous l'étendrons aux programmes de filtrage équationnel. Enfin, nous présenterons l'implantation de ce système de règles en Tom et les gains de performance obtenus

Open Platforms: New Challenges for Software Engineering

International audienceRecently, platforms running third-party applications have become very popular, in particular due to the explosion of the smartphone market. These open platforms propose a rich stream of applications, targeting general-purpose as well as customized user needs. Developing applications for such target platforms introduces new requirements and raises new challenges. This paper identifies key requirements for designing open platforms. After an overview of the existing approaches, we identify the challenges for the next generation of open platforms

Term-graph rewriting via explicit paths

International audienceThe notion of path is classical in graph theory but not directly used in the term rewriting community. The main idea of this work is to raise the notion of path to the level of first-order terms, i.e. paths become part of the terms and not just meta-information about them. These paths are represented by sequences of integers (positive or negative) and are interpreted as relative addresses in terms. In this way, paths can also be seen as a generalization of the classical notion of position for the first-order terms and of de Bruijn indexes for the lambda calculus. In this paper, we define an original framework called Addressed Term Rewriting where paths are used to represent pointers between subterms. Using this approach, any term-graph rewriting systems can be efficiently simulated using a rewrite-based environment

Rewriting Strategies in Java

International audienceIn any language designed to express transformations, the notion of rewrite rule is a key feature. Its conciseness as well as its strong theoretical foundations are essential. The notion of strategy is complementary: this describes how rules are applied. In this paper, we show how a high-level strategy language can be implemented in a Java setting. We present the integration of the visitor combinator design pattern into Tom. This corresponds to an interpreter for strategy expressions. To be more efficient, we present a compilation method based on bytecode specialization. This low-level transformation is expressed in Tom itself, using rules and strategies

Formal Islands

Motivated by the proliferation and usefulness of Domain Specific Languages as well as the demand in enriching well established languages by high level capabilities like pattern matching or strategic rewriting, we introduce the \emph{Formal Islands} framework. The main idea consists to integrate, in existing programs, formally defined parts called Islands, on which proofs and tests can be meaningfully developed. Then, Formal Islands could be safely dissolved into their hosting language to be transparently integrated in the existing user environment. The paper presents this generic framework and shows that the properties valid on the formal islands are also valid on the corresponding dissolved host codes. Formal Islands can be used as a general methodology to develop new DSL and we show that language extensions like sqlj ---embedding sql capabilities in Java ---, or Tom ---a Java language extension allowing for pattern matching and rewriting---are indeed Islands and they can therefore be used for formal software developments

Generic Encodings of Constructor Rewriting Systems

Rewriting is a formalism widely used in computer science and mathematical logic. The classical formalism has been extended, in the context of functional languages, with an order over the rules and, in the context of rewrite based languages, with the negation over patterns. We propose in this paper a concise and clear algorithm computing the difference over patterns which can be used to define generic encodings of constructor term rewriting systems with negation and order into classical term rewriting systems. As a direct consequence, established methods used for term rewriting systems can be applied to analyze properties of the extended systems. The approach can also be seen as a generic compiler which targets any language providing basic pattern matching primitives. The formalism provides also a new method for deciding if a set of patterns subsumes a given pattern and thus, for checking the presence of useless patterns or the completeness of a set of patterns.Comment: Added appendix with proofs and extended example

Faire levier sur les architectures logicielles pour guider et vérifier le développement d'applications SCC

National audienceA software architecture describes the structure of a computing system by specifying software components and their interactions. Mapping a software architecture to an implementation is a well known challenge. A key element of this mapping is the architecture's description of the data and control-flow interactions between components. The characterization of these interactions can be rather abstract or very concrete, providing more or less implementation guidance, programming support, and static verification. In this paper, we explore one point in the design space between abstract and concrete component interaction specifications. We introduce a notion of interaction contract that expresses allowed interactions between components, describing both data and control-flow constraints. This declaration is part of the architecture description, allows generation of extensive programming support, and enables various verifications. We instantiate our approach in an architecture description language for Sense/Compute/Control applications, and describe associated compilation and verification strategies.Une architecture logicielle décrit la structure d'un système informatique en spécifiant ses composants et leurs interactions. Projeter une architecture logicielle sur une implémentation est une tâche reconnue difficile. Un élément crucial de cette projection est la description architecturale des interactions entre les composants. La caractérisation de ces interactions peut être plutôt abstraite ou très concrète, fournissant plus ou moins de support de programmation et de possibilités de vérifications statiques. Nous explorons un point dans l'espace de conception entre les spécifications abstraites et concrètes des interactions de composants. Nous introduisons la notion de contrat d'interactions qui exprime les interactions autorisées. Cette déclaration architecturale permet la génération de support de programmation qui assure la conformité entre l'architecture et l'implémentation, et favorise diverses vérifications. Nous instancions notre approche sur un langage de description d'architectures pour les applications Sense/Compute/Control et décrivons les stratégies de compilation et de vérification associées

A Case for Human-Driven Software Development

International audienceHuman-Computer Interaction (HCI) plays a critical role in software systems, especially when targeting vulnerable individuals (e.g., assistive technologies). However, there exists a gap between well-tooled software development methodologies and HCI techniques, which are generally isolated from the development toolchain and require specific expertise. In this paper, we propose a human-driven software development methodology making User Interface (UI) a full-fledged dimension of software design. To make this methodology useful in practice, a UI design language and a user modeling language are integrated into a tool suite that guides the stakeholders during the development process, while ensuring the conformance between the UI design and its implementation